package com.sa.ibiz.demo.demo.domain;

import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.List;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonProperty.Access;
import lombok.Data;
import org.springframework.beans.BeanUtils;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.cglib.beans.BeanGenerator;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.FieldFill;
import java.util.Map;
import java.util.HashMap;
import org.springframework.util.StringUtils;
import com.sa.ibiz.demo.ibizutil.security.AuthenticationUser;
import java.util.Date;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size;
import org.springframework.util.DigestUtils;
import org.springframework.util.StringUtils;
import java.util.UUID;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
import org.springframework.cglib.beans.BeanCopier;
import com.sa.ibiz.demo.ibizutil.annotation.Dict;
import com.sa.ibiz.demo.ibizutil.domain.EntityBase;
import java.io.Serializable;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import java.math.BigInteger;
import com.sa.ibiz.demo.ibizutil.enums.FillMode;
import com.sa.ibiz.demo.ibizutil.enums.PredefinedType;
import com.sa.ibiz.demo.ibizutil.annotation.PreField;
import com.alibaba.fastjson.annotation.JSONField;

import com.sa.ibiz.demo.demo.domain.DataEntity;
import com.sa.ibiz.demo.demo.domain.QueryModel;

/**
 * 实体[DataEntity] 数据对象
 */
@TableName(value = "t_srfdataentity",resultMap = "DataEntityResultMap")
@JsonIgnoreProperties(ignoreUnknown = true)
@Data
public class DataEntity extends EntityBase implements Serializable{

    @JSONField(serialize = false)
    @JsonIgnore
    @TableField(exist = false)//关系主表数据
    private DataEntity der11de;
    @JSONField(serialize = false)
    @JsonIgnore
    @TableField(exist = false)//关系主表数据
    private QueryModel acquerymodel;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer acenabledp;
    private String acextinfo;
    private String acinfoformat;
    private String acinfoparam;
    private Integer acmaxcnt;
    private String acobject;
    private String acquerymodelid;
    @TableField(exist = false)//逻辑属性
    private String acquerymodelname;
    @Dict(dictName = "WorkflowMob_SortDirCodeList")
    private String acsortdir;
    private String acsortfield;
    private String bigicon;
    private String confighelper;
    @PreField(fill= FillMode.INSERT,preType = PredefinedType.CREATEDATE)
    private Timestamp createdate;
    @PreField(fill= FillMode.INSERT,preType = PredefinedType.CREATEMAN)
    @Dict(dictName = "WorkflowMob_SysOperatorCodeList")
    private String createman;
    private String dataaccobject;
    @Dict(dictName = "WorkflowMob_DEDataChgLogTypeCodeList")
    private Integer datachglogmode;
    private String datactrlint;
    private String datactrlobject;
    private String datanotifyhelper;
    @Dict(dictName = "WorkflowMob_CodeList105CodeList")
    private String dbstorage;
    private Integer dbversion;
    @Dict(dictName = "WorkflowMob_CodeList19CodeList")
    private String degroup;
    private String dehelper;
    @TableId(value= "deid",type=IdType.UUID)//指定主键生成策略
    private String deid;
    private String delogicname;
    private String dename;
    private String deobject;
    private Integer deorder;
    private String deparam;
    private String der11deid;
    @TableField(exist = false)//逻辑属性
    private String der11dename;
    private Integer detype;
    private String deuserparam;
    private Integer deversion;
    private String dgrowclasshelper;
    private Integer dgsummaryheight;
    private String dlkhelper;
    private Integer dynamicinterval;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer enablecolpriv;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer enableglobalmodel;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer exitingmodel;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer exportincempty;
    private String extablename;
    private String globalmodelobj;
    @Dict(dictName = "WorkflowMob_DEIndexModeCodeList")
    private Integer indexmode;
    private String infofield;
    private String infoformat;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer inheritmode;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer isdgrowedit;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer isenableaudit;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer isenabledp;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer isindexde;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer islogicvalid;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer ismultiprint;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer issupportfa;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer issystem;
    private String keyparams;
    private String licensecode;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer logauditdetail;
    private String memo;
    private String minorfieldname;
    private String minorfieldvalue;
    private String minortablename;
    @TableField(value= "multimajor")
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer mutlimajor;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer nodatainfo;
    @Dict(dictName = "WorkflowMob_DEPrintFuncCodeList")
    private String printfunc;
    private String reserver;
    private String reserver2;
    @TableField(value= "rowamount")
    private Integer rowamout;
    @TableField(exist = false)//逻辑属性
    private String rtinfo;
    private String smallicon;
    @Dict(dictName = "WorkflowMob_CodeList80CodeList")
    private String storagetype;
    private String tablename;
    @Dict(dictName = "WorkflowMob_DETableSpaceCodeList")
    private String tablespace;
    private String tipsinfo;
    private String tipsobject;
    @PreField(fill= FillMode.INSERT_UPDATE,preType = PredefinedType.UPDATEDATE)
    private Timestamp updatedate;
    @PreField(fill= FillMode.INSERT_UPDATE,preType = PredefinedType.UPDATEMAN)
    @Dict(dictName = "WorkflowMob_SysOperatorCodeList")
    private String updateman;
    @Dict(dictName = "WorkflowMob_CodeList71CodeList")
    private Integer useraction;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer validflag;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer vcflag;
    private Integer verchecktimer;
    private String verfield;
    private String verhelper;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer versioncheck;
    private String viewname;
    /**
     *  设置属性值[启动自填数据权限]
     *  @param acenabledp
     */
    public void setAcenabledp(Integer acenabledp){
        this.acenabledp = acenabledp;
        this.set("acenabledpdirtyflag",true);
    }
    /**
     *  获取属性值[启动自填数据权限]
     */
    public Integer getAcenabledp(){
        return this.acenabledp;
    }
    /**
     *  重置属性值[启动自填数据权限]
     */
    public void resetAcenabledp(){
        this.set("acenabledpdirtyflag",false);
        this.acenabledp = null;
    }
    /**
     *  设置属性值[自动填充附加信息]
     *  @param acextinfo
     */
    public void setAcextinfo(String acextinfo){
        if(StringUtils.isEmpty(acextinfo))
            acextinfo=null;
        this.acextinfo = acextinfo;
        this.set("acextinfodirtyflag",true);
    }
    /**
     *  获取属性值[自动填充附加信息]
     */
    public String getAcextinfo(){
        return this.acextinfo;
    }
    /**
     *  重置属性值[自动填充附加信息]
     */
    public void resetAcextinfo(){
        this.set("acextinfodirtyflag",false);
        this.acextinfo = null;
    }
    /**
     *  设置属性值[自动填充信息格式]
     *  @param acinfoformat
     */
    public void setAcinfoformat(String acinfoformat){
        if(StringUtils.isEmpty(acinfoformat))
            acinfoformat=null;
        this.acinfoformat = acinfoformat;
        this.set("acinfoformatdirtyflag",true);
    }
    /**
     *  获取属性值[自动填充信息格式]
     */
    public String getAcinfoformat(){
        return this.acinfoformat;
    }
    /**
     *  重置属性值[自动填充信息格式]
     */
    public void resetAcinfoformat(){
        this.set("acinfoformatdirtyflag",false);
        this.acinfoformat = null;
    }
    /**
     *  设置属性值[自动填充信息参数]
     *  @param acinfoparam
     */
    public void setAcinfoparam(String acinfoparam){
        if(StringUtils.isEmpty(acinfoparam))
            acinfoparam=null;
        this.acinfoparam = acinfoparam;
        this.set("acinfoparamdirtyflag",true);
    }
    /**
     *  获取属性值[自动填充信息参数]
     */
    public String getAcinfoparam(){
        return this.acinfoparam;
    }
    /**
     *  重置属性值[自动填充信息参数]
     */
    public void resetAcinfoparam(){
        this.set("acinfoparamdirtyflag",false);
        this.acinfoparam = null;
    }
    /**
     *  设置属性值[自填最大数量]
     *  @param acmaxcnt
     */
    public void setAcmaxcnt(Integer acmaxcnt){
        this.acmaxcnt = acmaxcnt;
        this.set("acmaxcntdirtyflag",true);
    }
    /**
     *  获取属性值[自填最大数量]
     */
    public Integer getAcmaxcnt(){
        return this.acmaxcnt;
    }
    /**
     *  重置属性值[自填最大数量]
     */
    public void resetAcmaxcnt(){
        this.set("acmaxcntdirtyflag",false);
        this.acmaxcnt = null;
    }
    /**
     *  设置属性值[自动填充处理对象]
     *  @param acobject
     */
    public void setAcobject(String acobject){
        if(StringUtils.isEmpty(acobject))
            acobject=null;
        this.acobject = acobject;
        this.set("acobjectdirtyflag",true);
    }
    /**
     *  获取属性值[自动填充处理对象]
     */
    public String getAcobject(){
        return this.acobject;
    }
    /**
     *  重置属性值[自动填充处理对象]
     */
    public void resetAcobject(){
        this.set("acobjectdirtyflag",false);
        this.acobject = null;
    }
    /**
     *  设置属性值[数据实体_自填查询模型]
     *  @param acquerymodelid
     */
    public void setAcquerymodelid(String acquerymodelid){
        if(StringUtils.isEmpty(acquerymodelid))
            acquerymodelid=null;
        this.acquerymodelid = acquerymodelid;
        this.set("acquerymodeliddirtyflag",true);
    }
    /**
     *  获取属性值[数据实体_自填查询模型]
     */
    public String getAcquerymodelid(){
        return this.acquerymodelid;
    }
    /**
     *  重置属性值[数据实体_自填查询模型]
     */
    public void resetAcquerymodelid(){
        this.set("acquerymodeliddirtyflag",false);
        this.acquerymodelid = null;
    }
    /**
     *  设置属性值[自填查询模型]
     *  @param acquerymodelname
     */
    public void setAcquerymodelname(String acquerymodelname){
        if(StringUtils.isEmpty(acquerymodelname))
            acquerymodelname=null;
        this.acquerymodelname = acquerymodelname;
        this.set("acquerymodelnamedirtyflag",true);
    }
    /**
     *  获取属性值[自填查询模型]
     */
    public String getAcquerymodelname(){
        return this.acquerymodelname;
    }
    /**
     *  重置属性值[自填查询模型]
     */
    public void resetAcquerymodelname(){
        this.set("acquerymodelnamedirtyflag",false);
        this.acquerymodelname = null;
    }
    /**
     *  设置属性值[自动排序方向]
     *  @param acsortdir
     */
    public void setAcsortdir(String acsortdir){
        if(StringUtils.isEmpty(acsortdir))
            acsortdir=null;
        this.acsortdir = acsortdir;
        this.set("acsortdirdirtyflag",true);
    }
    /**
     *  获取属性值[自动排序方向]
     */
    public String getAcsortdir(){
        return this.acsortdir;
    }
    /**
     *  重置属性值[自动排序方向]
     */
    public void resetAcsortdir(){
        this.set("acsortdirdirtyflag",false);
        this.acsortdir = null;
    }
    /**
     *  设置属性值[自填排序字段]
     *  @param acsortfield
     */
    public void setAcsortfield(String acsortfield){
        if(StringUtils.isEmpty(acsortfield))
            acsortfield=null;
        this.acsortfield = acsortfield;
        this.set("acsortfielddirtyflag",true);
    }
    /**
     *  获取属性值[自填排序字段]
     */
    public String getAcsortfield(){
        return this.acsortfield;
    }
    /**
     *  重置属性值[自填排序字段]
     */
    public void resetAcsortfield(){
        this.set("acsortfielddirtyflag",false);
        this.acsortfield = null;
    }
    /**
     *  设置属性值[大图标]
     *  @param bigicon
     */
    public void setBigicon(String bigicon){
        if(StringUtils.isEmpty(bigicon))
            bigicon=null;
        this.bigicon = bigicon;
        this.set("bigicondirtyflag",true);
    }
    /**
     *  获取属性值[大图标]
     */
    public String getBigicon(){
        return this.bigicon;
    }
    /**
     *  重置属性值[大图标]
     */
    public void resetBigicon(){
        this.set("bigicondirtyflag",false);
        this.bigicon = null;
    }
    /**
     *  设置属性值[配置辅助对象]
     *  @param confighelper
     */
    public void setConfighelper(String confighelper){
        if(StringUtils.isEmpty(confighelper))
            confighelper=null;
        this.confighelper = confighelper;
        this.set("confighelperdirtyflag",true);
    }
    /**
     *  获取属性值[配置辅助对象]
     */
    public String getConfighelper(){
        return this.confighelper;
    }
    /**
     *  重置属性值[配置辅助对象]
     */
    public void resetConfighelper(){
        this.set("confighelperdirtyflag",false);
        this.confighelper = null;
    }
    /**
     *  设置属性值[建立时间]
     *  @param createdate
     */
    public void setCreatedate(Timestamp createdate){
        this.createdate = createdate;
        this.set("createdatedirtyflag",true);
    }
    /**
     *  获取属性值[建立时间]
     */
    public Timestamp getCreatedate(){
        return this.createdate;
    }
    /**
     *  重置属性值[建立时间]
     */
    public void resetCreatedate(){
        this.set("createdatedirtyflag",false);
        this.createdate = null;
    }
    /**
     *  设置属性值[建立人]
     *  @param createman
     */
    public void setCreateman(String createman){
        if(StringUtils.isEmpty(createman))
            createman=null;
        this.createman = createman;
        this.set("createmandirtyflag",true);
    }
    /**
     *  获取属性值[建立人]
     */
    public String getCreateman(){
        return this.createman;
    }
    /**
     *  重置属性值[建立人]
     */
    public void resetCreateman(){
        this.set("createmandirtyflag",false);
        this.createman = null;
    }
    /**
     *  设置属性值[数据访问控制对象]
     *  @param dataaccobject
     */
    public void setDataaccobject(String dataaccobject){
        if(StringUtils.isEmpty(dataaccobject))
            dataaccobject=null;
        this.dataaccobject = dataaccobject;
        this.set("dataaccobjectdirtyflag",true);
    }
    /**
     *  获取属性值[数据访问控制对象]
     */
    public String getDataaccobject(){
        return this.dataaccobject;
    }
    /**
     *  重置属性值[数据访问控制对象]
     */
    public void resetDataaccobject(){
        this.set("dataaccobjectdirtyflag",false);
        this.dataaccobject = null;
    }
    /**
     *  设置属性值[数据变更日志类型]
     *  @param datachglogmode
     */
    public void setDatachglogmode(Integer datachglogmode){
        this.datachglogmode = datachglogmode;
        this.set("datachglogmodedirtyflag",true);
    }
    /**
     *  获取属性值[数据变更日志类型]
     */
    public Integer getDatachglogmode(){
        return this.datachglogmode;
    }
    /**
     *  重置属性值[数据变更日志类型]
     */
    public void resetDatachglogmode(){
        this.set("datachglogmodedirtyflag",false);
        this.datachglogmode = null;
    }
    /**
     *  设置属性值[数据访问对象接口]
     *  @param datactrlint
     */
    public void setDatactrlint(String datactrlint){
        if(StringUtils.isEmpty(datactrlint))
            datactrlint=null;
        this.datactrlint = datactrlint;
        this.set("datactrlintdirtyflag",true);
    }
    /**
     *  获取属性值[数据访问对象接口]
     */
    public String getDatactrlint(){
        return this.datactrlint;
    }
    /**
     *  重置属性值[数据访问对象接口]
     */
    public void resetDatactrlint(){
        this.set("datactrlintdirtyflag",false);
        this.datactrlint = null;
    }
    /**
     *  设置属性值[数据访问对象]
     *  @param datactrlobject
     */
    public void setDatactrlobject(String datactrlobject){
        if(StringUtils.isEmpty(datactrlobject))
            datactrlobject=null;
        this.datactrlobject = datactrlobject;
        this.set("datactrlobjectdirtyflag",true);
    }
    /**
     *  获取属性值[数据访问对象]
     */
    public String getDatactrlobject(){
        return this.datactrlobject;
    }
    /**
     *  重置属性值[数据访问对象]
     */
    public void resetDatactrlobject(){
        this.set("datactrlobjectdirtyflag",false);
        this.datactrlobject = null;
    }
    /**
     *  设置属性值[数据通知辅助对象]
     *  @param datanotifyhelper
     */
    public void setDatanotifyhelper(String datanotifyhelper){
        if(StringUtils.isEmpty(datanotifyhelper))
            datanotifyhelper=null;
        this.datanotifyhelper = datanotifyhelper;
        this.set("datanotifyhelperdirtyflag",true);
    }
    /**
     *  获取属性值[数据通知辅助对象]
     */
    public String getDatanotifyhelper(){
        return this.datanotifyhelper;
    }
    /**
     *  重置属性值[数据通知辅助对象]
     */
    public void resetDatanotifyhelper(){
        this.set("datanotifyhelperdirtyflag",false);
        this.datanotifyhelper = null;
    }
    /**
     *  设置属性值[数据库存储]
     *  @param dbstorage
     */
    public void setDbstorage(String dbstorage){
        if(StringUtils.isEmpty(dbstorage))
            dbstorage=null;
        this.dbstorage = dbstorage;
        this.set("dbstoragedirtyflag",true);
    }
    /**
     *  获取属性值[数据库存储]
     */
    public String getDbstorage(){
        return this.dbstorage;
    }
    /**
     *  重置属性值[数据库存储]
     */
    public void resetDbstorage(){
        this.set("dbstoragedirtyflag",false);
        this.dbstorage = null;
    }
    /**
     *  设置属性值[数据结构版本]
     *  @param dbversion
     */
    public void setDbversion(Integer dbversion){
        this.dbversion = dbversion;
        this.set("dbversiondirtyflag",true);
    }
    /**
     *  获取属性值[数据结构版本]
     */
    public Integer getDbversion(){
        return this.dbversion;
    }
    /**
     *  重置属性值[数据结构版本]
     */
    public void resetDbversion(){
        this.set("dbversiondirtyflag",false);
        this.dbversion = null;
    }
    /**
     *  设置属性值[实体归属]
     *  @param degroup
     */
    public void setDegroup(String degroup){
        if(StringUtils.isEmpty(degroup))
            degroup=null;
        this.degroup = degroup;
        this.set("degroupdirtyflag",true);
    }
    /**
     *  获取属性值[实体归属]
     */
    public String getDegroup(){
        return this.degroup;
    }
    /**
     *  重置属性值[实体归属]
     */
    public void resetDegroup(){
        this.set("degroupdirtyflag",false);
        this.degroup = null;
    }
    /**
     *  设置属性值[实体辅助对象]
     *  @param dehelper
     */
    public void setDehelper(String dehelper){
        if(StringUtils.isEmpty(dehelper))
            dehelper=null;
        this.dehelper = dehelper;
        this.set("dehelperdirtyflag",true);
    }
    /**
     *  获取属性值[实体辅助对象]
     */
    public String getDehelper(){
        return this.dehelper;
    }
    /**
     *  重置属性值[实体辅助对象]
     */
    public void resetDehelper(){
        this.set("dehelperdirtyflag",false);
        this.dehelper = null;
    }
    /**
     *  设置属性值[实体标识]
     *  @param deid
     */
    public void setDeid(String deid){
        if(StringUtils.isEmpty(deid))
            deid=null;
        this.deid = deid;
        this.set("deiddirtyflag",true);
    }
    /**
     *  获取属性值[实体标识]
     */
    public String getDeid(){
        return this.deid;
    }
    /**
     *  重置属性值[实体标识]
     */
    public void resetDeid(){
        this.set("deiddirtyflag",false);
        this.deid = null;
    }
    /**
     *  设置属性值[逻辑名称]
     *  @param delogicname
     */
    public void setDelogicname(String delogicname){
        if(StringUtils.isEmpty(delogicname))
            delogicname=null;
        this.delogicname = delogicname;
        this.set("delogicnamedirtyflag",true);
    }
    /**
     *  获取属性值[逻辑名称]
     */
    public String getDelogicname(){
        return this.delogicname;
    }
    /**
     *  重置属性值[逻辑名称]
     */
    public void resetDelogicname(){
        this.set("delogicnamedirtyflag",false);
        this.delogicname = null;
    }
    /**
     *  设置属性值[实体名称]
     *  @param dename
     */
    public void setDename(String dename){
        if(StringUtils.isEmpty(dename))
            dename=null;
        this.dename = dename;
        this.set("denamedirtyflag",true);
    }
    /**
     *  获取属性值[实体名称]
     */
    public String getDename(){
        return this.dename;
    }
    /**
     *  重置属性值[实体名称]
     */
    public void resetDename(){
        this.set("denamedirtyflag",false);
        this.dename = null;
    }
    /**
     *  设置属性值[数据对象类]
     *  @param deobject
     */
    public void setDeobject(String deobject){
        if(StringUtils.isEmpty(deobject))
            deobject=null;
        this.deobject = deobject;
        this.set("deobjectdirtyflag",true);
    }
    /**
     *  获取属性值[数据对象类]
     */
    public String getDeobject(){
        return this.deobject;
    }
    /**
     *  重置属性值[数据对象类]
     */
    public void resetDeobject(){
        this.set("deobjectdirtyflag",false);
        this.deobject = null;
    }
    /**
     *  设置属性值[实体次序]
     *  @param deorder
     */
    public void setDeorder(Integer deorder){
        this.deorder = deorder;
        this.set("deorderdirtyflag",true);
    }
    /**
     *  获取属性值[实体次序]
     */
    public Integer getDeorder(){
        return this.deorder;
    }
    /**
     *  重置属性值[实体次序]
     */
    public void resetDeorder(){
        this.set("deorderdirtyflag",false);
        this.deorder = null;
    }
    /**
     *  设置属性值[实体参数]
     *  @param deparam
     */
    public void setDeparam(String deparam){
        if(StringUtils.isEmpty(deparam))
            deparam=null;
        this.deparam = deparam;
        this.set("deparamdirtyflag",true);
    }
    /**
     *  获取属性值[实体参数]
     */
    public String getDeparam(){
        return this.deparam;
    }
    /**
     *  重置属性值[实体参数]
     */
    public void resetDeparam(){
        this.set("deparamdirtyflag",false);
        this.deparam = null;
    }
    /**
     *  设置属性值[1:1关系实体]
     *  @param der11deid
     */
    public void setDer11deid(String der11deid){
        if(StringUtils.isEmpty(der11deid))
            der11deid=null;
        this.der11deid = der11deid;
        this.set("der11deiddirtyflag",true);
    }
    /**
     *  获取属性值[1:1关系实体]
     */
    public String getDer11deid(){
        return this.der11deid;
    }
    /**
     *  重置属性值[1:1关系实体]
     */
    public void resetDer11deid(){
        this.set("der11deiddirtyflag",false);
        this.der11deid = null;
    }
    /**
     *  设置属性值[DER11DENAME]
     *  @param der11dename
     */
    public void setDer11dename(String der11dename){
        if(StringUtils.isEmpty(der11dename))
            der11dename=null;
        this.der11dename = der11dename;
        this.set("der11denamedirtyflag",true);
    }
    /**
     *  获取属性值[DER11DENAME]
     */
    public String getDer11dename(){
        return this.der11dename;
    }
    /**
     *  重置属性值[DER11DENAME]
     */
    public void resetDer11dename(){
        this.set("der11denamedirtyflag",false);
        this.der11dename = null;
    }
    /**
     *  设置属性值[实体类型]
     *  @param detype
     */
    public void setDetype(Integer detype){
        this.detype = detype;
        this.set("detypedirtyflag",true);
    }
    /**
     *  获取属性值[实体类型]
     */
    public Integer getDetype(){
        return this.detype;
    }
    /**
     *  重置属性值[实体类型]
     */
    public void resetDetype(){
        this.set("detypedirtyflag",false);
        this.detype = null;
    }
    /**
     *  设置属性值[实体用户参数]
     *  @param deuserparam
     */
    public void setDeuserparam(String deuserparam){
        if(StringUtils.isEmpty(deuserparam))
            deuserparam=null;
        this.deuserparam = deuserparam;
        this.set("deuserparamdirtyflag",true);
    }
    /**
     *  获取属性值[实体用户参数]
     */
    public String getDeuserparam(){
        return this.deuserparam;
    }
    /**
     *  重置属性值[实体用户参数]
     */
    public void resetDeuserparam(){
        this.set("deuserparamdirtyflag",false);
        this.deuserparam = null;
    }
    /**
     *  设置属性值[版本]
     *  @param deversion
     */
    public void setDeversion(Integer deversion){
        this.deversion = deversion;
        this.set("deversiondirtyflag",true);
    }
    /**
     *  获取属性值[版本]
     */
    public Integer getDeversion(){
        return this.deversion;
    }
    /**
     *  重置属性值[版本]
     */
    public void resetDeversion(){
        this.set("deversiondirtyflag",false);
        this.deversion = null;
    }
    /**
     *  设置属性值[表格行样式辅助对象]
     *  @param dgrowclasshelper
     */
    public void setDgrowclasshelper(String dgrowclasshelper){
        if(StringUtils.isEmpty(dgrowclasshelper))
            dgrowclasshelper=null;
        this.dgrowclasshelper = dgrowclasshelper;
        this.set("dgrowclasshelperdirtyflag",true);
    }
    /**
     *  获取属性值[表格行样式辅助对象]
     */
    public String getDgrowclasshelper(){
        return this.dgrowclasshelper;
    }
    /**
     *  重置属性值[表格行样式辅助对象]
     */
    public void resetDgrowclasshelper(){
        this.set("dgrowclasshelperdirtyflag",false);
        this.dgrowclasshelper = null;
    }
    /**
     *  设置属性值[表格信息区高度]
     *  @param dgsummaryheight
     */
    public void setDgsummaryheight(Integer dgsummaryheight){
        this.dgsummaryheight = dgsummaryheight;
        this.set("dgsummaryheightdirtyflag",true);
    }
    /**
     *  获取属性值[表格信息区高度]
     */
    public Integer getDgsummaryheight(){
        return this.dgsummaryheight;
    }
    /**
     *  重置属性值[表格信息区高度]
     */
    public void resetDgsummaryheight(){
        this.set("dgsummaryheightdirtyflag",false);
        this.dgsummaryheight = null;
    }
    /**
     *  设置属性值[数据锁辅助对象]
     *  @param dlkhelper
     */
    public void setDlkhelper(String dlkhelper){
        if(StringUtils.isEmpty(dlkhelper))
            dlkhelper=null;
        this.dlkhelper = dlkhelper;
        this.set("dlkhelperdirtyflag",true);
    }
    /**
     *  获取属性值[数据锁辅助对象]
     */
    public String getDlkhelper(){
        return this.dlkhelper;
    }
    /**
     *  重置属性值[数据锁辅助对象]
     */
    public void resetDlkhelper(){
        this.set("dlkhelperdirtyflag",false);
        this.dlkhelper = null;
    }
    /**
     *  设置属性值[动态表间隔时间]
     *  @param dynamicinterval
     */
    public void setDynamicinterval(Integer dynamicinterval){
        this.dynamicinterval = dynamicinterval;
        this.set("dynamicintervaldirtyflag",true);
    }
    /**
     *  获取属性值[动态表间隔时间]
     */
    public Integer getDynamicinterval(){
        return this.dynamicinterval;
    }
    /**
     *  重置属性值[动态表间隔时间]
     */
    public void resetDynamicinterval(){
        this.set("dynamicintervaldirtyflag",false);
        this.dynamicinterval = null;
    }
    /**
     *  设置属性值[启用列权限控制]
     *  @param enablecolpriv
     */
    public void setEnablecolpriv(Integer enablecolpriv){
        this.enablecolpriv = enablecolpriv;
        this.set("enablecolprivdirtyflag",true);
    }
    /**
     *  获取属性值[启用列权限控制]
     */
    public Integer getEnablecolpriv(){
        return this.enablecolpriv;
    }
    /**
     *  重置属性值[启用列权限控制]
     */
    public void resetEnablecolpriv(){
        this.set("enablecolprivdirtyflag",false);
        this.enablecolpriv = null;
    }
    /**
     *  设置属性值[启用全局模型缓存]
     *  @param enableglobalmodel
     */
    public void setEnableglobalmodel(Integer enableglobalmodel){
        this.enableglobalmodel = enableglobalmodel;
        this.set("enableglobalmodeldirtyflag",true);
    }
    /**
     *  获取属性值[启用全局模型缓存]
     */
    public Integer getEnableglobalmodel(){
        return this.enableglobalmodel;
    }
    /**
     *  重置属性值[启用全局模型缓存]
     */
    public void resetEnableglobalmodel(){
        this.set("enableglobalmodeldirtyflag",false);
        this.enableglobalmodel = null;
    }
    /**
     *  设置属性值[现存模型]
     *  @param exitingmodel
     */
    public void setExitingmodel(Integer exitingmodel){
        this.exitingmodel = exitingmodel;
        this.set("exitingmodeldirtyflag",true);
    }
    /**
     *  获取属性值[现存模型]
     */
    public Integer getExitingmodel(){
        return this.exitingmodel;
    }
    /**
     *  重置属性值[现存模型]
     */
    public void resetExitingmodel(){
        this.set("exitingmodeldirtyflag",false);
        this.exitingmodel = null;
    }
    /**
     *  设置属性值[导出模型包含空值]
     *  @param exportincempty
     */
    public void setExportincempty(Integer exportincempty){
        this.exportincempty = exportincempty;
        this.set("exportincemptydirtyflag",true);
    }
    /**
     *  获取属性值[导出模型包含空值]
     */
    public Integer getExportincempty(){
        return this.exportincempty;
    }
    /**
     *  重置属性值[导出模型包含空值]
     */
    public void resetExportincempty(){
        this.set("exportincemptydirtyflag",false);
        this.exportincempty = null;
    }
    /**
     *  设置属性值[用户表]
     *  @param extablename
     */
    public void setExtablename(String extablename){
        if(StringUtils.isEmpty(extablename))
            extablename=null;
        this.extablename = extablename;
        this.set("extablenamedirtyflag",true);
    }
    /**
     *  获取属性值[用户表]
     */
    public String getExtablename(){
        return this.extablename;
    }
    /**
     *  重置属性值[用户表]
     */
    public void resetExtablename(){
        this.set("extablenamedirtyflag",false);
        this.extablename = null;
    }
    /**
     *  设置属性值[全局模型对象]
     *  @param globalmodelobj
     */
    public void setGlobalmodelobj(String globalmodelobj){
        if(StringUtils.isEmpty(globalmodelobj))
            globalmodelobj=null;
        this.globalmodelobj = globalmodelobj;
        this.set("globalmodelobjdirtyflag",true);
    }
    /**
     *  获取属性值[全局模型对象]
     */
    public String getGlobalmodelobj(){
        return this.globalmodelobj;
    }
    /**
     *  重置属性值[全局模型对象]
     */
    public void resetGlobalmodelobj(){
        this.set("globalmodelobjdirtyflag",false);
        this.globalmodelobj = null;
    }
    /**
     *  设置属性值[索引模式]
     *  @param indexmode
     */
    public void setIndexmode(Integer indexmode){
        this.indexmode = indexmode;
        this.set("indexmodedirtyflag",true);
    }
    /**
     *  获取属性值[索引模式]
     */
    public Integer getIndexmode(){
        return this.indexmode;
    }
    /**
     *  重置属性值[索引模式]
     */
    public void resetIndexmode(){
        this.set("indexmodedirtyflag",false);
        this.indexmode = null;
    }
    /**
     *  设置属性值[信息属性参数]
     *  @param infofield
     */
    public void setInfofield(String infofield){
        if(StringUtils.isEmpty(infofield))
            infofield=null;
        this.infofield = infofield;
        this.set("infofielddirtyflag",true);
    }
    /**
     *  获取属性值[信息属性参数]
     */
    public String getInfofield(){
        return this.infofield;
    }
    /**
     *  重置属性值[信息属性参数]
     */
    public void resetInfofield(){
        this.set("infofielddirtyflag",false);
        this.infofield = null;
    }
    /**
     *  设置属性值[信息格式化]
     *  @param infoformat
     */
    public void setInfoformat(String infoformat){
        if(StringUtils.isEmpty(infoformat))
            infoformat=null;
        this.infoformat = infoformat;
        this.set("infoformatdirtyflag",true);
    }
    /**
     *  获取属性值[信息格式化]
     */
    public String getInfoformat(){
        return this.infoformat;
    }
    /**
     *  重置属性值[信息格式化]
     */
    public void resetInfoformat(){
        this.set("infoformatdirtyflag",false);
        this.infoformat = null;
    }
    /**
     *  设置属性值[继承模式]
     *  @param inheritmode
     */
    public void setInheritmode(Integer inheritmode){
        this.inheritmode = inheritmode;
        this.set("inheritmodedirtyflag",true);
    }
    /**
     *  获取属性值[继承模式]
     */
    public Integer getInheritmode(){
        return this.inheritmode;
    }
    /**
     *  重置属性值[继承模式]
     */
    public void resetInheritmode(){
        this.set("inheritmodedirtyflag",false);
        this.inheritmode = null;
    }
    /**
     *  设置属性值[启用表格行编辑]
     *  @param isdgrowedit
     */
    public void setIsdgrowedit(Integer isdgrowedit){
        this.isdgrowedit = isdgrowedit;
        this.set("isdgroweditdirtyflag",true);
    }
    /**
     *  获取属性值[启用表格行编辑]
     */
    public Integer getIsdgrowedit(){
        return this.isdgrowedit;
    }
    /**
     *  重置属性值[启用表格行编辑]
     */
    public void resetIsdgrowedit(){
        this.set("isdgroweditdirtyflag",false);
        this.isdgrowedit = null;
    }
    /**
     *  设置属性值[启用审计]
     *  @param isenableaudit
     */
    public void setIsenableaudit(Integer isenableaudit){
        this.isenableaudit = isenableaudit;
        this.set("isenableauditdirtyflag",true);
    }
    /**
     *  获取属性值[启用审计]
     */
    public Integer getIsenableaudit(){
        return this.isenableaudit;
    }
    /**
     *  重置属性值[启用审计]
     */
    public void resetIsenableaudit(){
        this.set("isenableauditdirtyflag",false);
        this.isenableaudit = null;
    }
    /**
     *  设置属性值[启用数据权限]
     *  @param isenabledp
     */
    public void setIsenabledp(Integer isenabledp){
        this.isenabledp = isenabledp;
        this.set("isenabledpdirtyflag",true);
    }
    /**
     *  获取属性值[启用数据权限]
     */
    public Integer getIsenabledp(){
        return this.isenabledp;
    }
    /**
     *  重置属性值[启用数据权限]
     */
    public void resetIsenabledp(){
        this.set("isenabledpdirtyflag",false);
        this.isenabledp = null;
    }
    /**
     *  设置属性值[索引实体]
     *  @param isindexde
     */
    public void setIsindexde(Integer isindexde){
        this.isindexde = isindexde;
        this.set("isindexdedirtyflag",true);
    }
    /**
     *  获取属性值[索引实体]
     */
    public Integer getIsindexde(){
        return this.isindexde;
    }
    /**
     *  重置属性值[索引实体]
     */
    public void resetIsindexde(){
        this.set("isindexdedirtyflag",false);
        this.isindexde = null;
    }
    /**
     *  设置属性值[启用逻辑有效]
     *  @param islogicvalid
     */
    public void setIslogicvalid(Integer islogicvalid){
        this.islogicvalid = islogicvalid;
        this.set("islogicvaliddirtyflag",true);
    }
    /**
     *  获取属性值[启用逻辑有效]
     */
    public Integer getIslogicvalid(){
        return this.islogicvalid;
    }
    /**
     *  重置属性值[启用逻辑有效]
     */
    public void resetIslogicvalid(){
        this.set("islogicvaliddirtyflag",false);
        this.islogicvalid = null;
    }
    /**
     *  设置属性值[多选打印]
     *  @param ismultiprint
     */
    public void setIsmultiprint(Integer ismultiprint){
        this.ismultiprint = ismultiprint;
        this.set("ismultiprintdirtyflag",true);
    }
    /**
     *  获取属性值[多选打印]
     */
    public Integer getIsmultiprint(){
        return this.ismultiprint;
    }
    /**
     *  重置属性值[多选打印]
     */
    public void resetIsmultiprint(){
        this.set("ismultiprintdirtyflag",false);
        this.ismultiprint = null;
    }
    /**
     *  设置属性值[数据附件]
     *  @param issupportfa
     */
    public void setIssupportfa(Integer issupportfa){
        this.issupportfa = issupportfa;
        this.set("issupportfadirtyflag",true);
    }
    /**
     *  获取属性值[数据附件]
     */
    public Integer getIssupportfa(){
        return this.issupportfa;
    }
    /**
     *  重置属性值[数据附件]
     */
    public void resetIssupportfa(){
        this.set("issupportfadirtyflag",false);
        this.issupportfa = null;
    }
    /**
     *  设置属性值[系统实体]
     *  @param issystem
     */
    public void setIssystem(Integer issystem){
        this.issystem = issystem;
        this.set("issystemdirtyflag",true);
    }
    /**
     *  获取属性值[系统实体]
     */
    public Integer getIssystem(){
        return this.issystem;
    }
    /**
     *  重置属性值[系统实体]
     */
    public void resetIssystem(){
        this.set("issystemdirtyflag",false);
        this.issystem = null;
    }
    /**
     *  设置属性值[主键参数]
     *  @param keyparams
     */
    public void setKeyparams(String keyparams){
        if(StringUtils.isEmpty(keyparams))
            keyparams=null;
        this.keyparams = keyparams;
        this.set("keyparamsdirtyflag",true);
    }
    /**
     *  获取属性值[主键参数]
     */
    public String getKeyparams(){
        return this.keyparams;
    }
    /**
     *  重置属性值[主键参数]
     */
    public void resetKeyparams(){
        this.set("keyparamsdirtyflag",false);
        this.keyparams = null;
    }
    /**
     *  设置属性值[授权代码]
     *  @param licensecode
     */
    public void setLicensecode(String licensecode){
        if(StringUtils.isEmpty(licensecode))
            licensecode=null;
        this.licensecode = licensecode;
        this.set("licensecodedirtyflag",true);
    }
    /**
     *  获取属性值[授权代码]
     */
    public String getLicensecode(){
        return this.licensecode;
    }
    /**
     *  重置属性值[授权代码]
     */
    public void resetLicensecode(){
        this.set("licensecodedirtyflag",false);
        this.licensecode = null;
    }
    /**
     *  设置属性值[记录审计明细]
     *  @param logauditdetail
     */
    public void setLogauditdetail(Integer logauditdetail){
        this.logauditdetail = logauditdetail;
        this.set("logauditdetaildirtyflag",true);
    }
    /**
     *  获取属性值[记录审计明细]
     */
    public Integer getLogauditdetail(){
        return this.logauditdetail;
    }
    /**
     *  重置属性值[记录审计明细]
     */
    public void resetLogauditdetail(){
        this.set("logauditdetaildirtyflag",false);
        this.logauditdetail = null;
    }
    /**
     *  设置属性值[备注]
     *  @param memo
     */
    public void setMemo(String memo){
        if(StringUtils.isEmpty(memo))
            memo=null;
        this.memo = memo;
        this.set("memodirtyflag",true);
    }
    /**
     *  获取属性值[备注]
     */
    public String getMemo(){
        return this.memo;
    }
    /**
     *  重置属性值[备注]
     */
    public void resetMemo(){
        this.set("memodirtyflag",false);
        this.memo = null;
    }
    /**
     *  设置属性值[附表标识字段]
     *  @param minorfieldname
     */
    public void setMinorfieldname(String minorfieldname){
        if(StringUtils.isEmpty(minorfieldname))
            minorfieldname=null;
        this.minorfieldname = minorfieldname;
        this.set("minorfieldnamedirtyflag",true);
    }
    /**
     *  获取属性值[附表标识字段]
     */
    public String getMinorfieldname(){
        return this.minorfieldname;
    }
    /**
     *  重置属性值[附表标识字段]
     */
    public void resetMinorfieldname(){
        this.set("minorfieldnamedirtyflag",false);
        this.minorfieldname = null;
    }
    /**
     *  设置属性值[附表标识值]
     *  @param minorfieldvalue
     */
    public void setMinorfieldvalue(String minorfieldvalue){
        if(StringUtils.isEmpty(minorfieldvalue))
            minorfieldvalue=null;
        this.minorfieldvalue = minorfieldvalue;
        this.set("minorfieldvaluedirtyflag",true);
    }
    /**
     *  获取属性值[附表标识值]
     */
    public String getMinorfieldvalue(){
        return this.minorfieldvalue;
    }
    /**
     *  重置属性值[附表标识值]
     */
    public void resetMinorfieldvalue(){
        this.set("minorfieldvaluedirtyflag",false);
        this.minorfieldvalue = null;
    }
    /**
     *  设置属性值[附表名称]
     *  @param minortablename
     */
    public void setMinortablename(String minortablename){
        if(StringUtils.isEmpty(minortablename))
            minortablename=null;
        this.minortablename = minortablename;
        this.set("minortablenamedirtyflag",true);
    }
    /**
     *  获取属性值[附表名称]
     */
    public String getMinortablename(){
        return this.minortablename;
    }
    /**
     *  重置属性值[附表名称]
     */
    public void resetMinortablename(){
        this.set("minortablenamedirtyflag",false);
        this.minortablename = null;
    }
    /**
     *  设置属性值[多主实体模式]
     *  @param mutlimajor
     */
    public void setMutlimajor(Integer mutlimajor){
        this.mutlimajor = mutlimajor;
        this.set("mutlimajordirtyflag",true);
    }
     /**
     *    mutlimajor :multimajor
     *   当属性名称与代码名称不一致时，
     *   多发一套get属性名称方法给gridvo用
     */
    public Integer getMultimajor(){
        return  mutlimajor;
    }
     /**
     *    mutlimajor :multimajor
     *   关闭mp驼峰转换，当属性名称与代码名称不一致时，多发一套set用于值注入
     */
    public void setMultimajor(Integer multimajor){
        this.mutlimajor=multimajor;
    }
    /**
     *  获取属性值[多主实体模式]
     */
    public Integer getMutlimajor(){
        return this.mutlimajor;
    }
    /**
     *  重置属性值[多主实体模式]
     */
    public void resetMutlimajor(){
        this.set("mutlimajordirtyflag",false);
        this.mutlimajor = null;
    }
    /**
     *  设置属性值[无数据信息]
     *  @param nodatainfo
     */
    public void setNodatainfo(Integer nodatainfo){
        this.nodatainfo = nodatainfo;
        this.set("nodatainfodirtyflag",true);
    }
    /**
     *  获取属性值[无数据信息]
     */
    public Integer getNodatainfo(){
        return this.nodatainfo;
    }
    /**
     *  重置属性值[无数据信息]
     */
    public void resetNodatainfo(){
        this.set("nodatainfodirtyflag",false);
        this.nodatainfo = null;
    }
    /**
     *  设置属性值[打印功能]
     *  @param printfunc
     */
    public void setPrintfunc(String printfunc){
        if(StringUtils.isEmpty(printfunc))
            printfunc=null;
        this.printfunc = printfunc;
        this.set("printfuncdirtyflag",true);
    }
    /**
     *  获取属性值[打印功能]
     */
    public String getPrintfunc(){
        return this.printfunc;
    }
    /**
     *  重置属性值[打印功能]
     */
    public void resetPrintfunc(){
        this.set("printfuncdirtyflag",false);
        this.printfunc = null;
    }
    /**
     *  设置属性值[保留1]
     *  @param reserver
     */
    public void setReserver(String reserver){
        if(StringUtils.isEmpty(reserver))
            reserver=null;
        this.reserver = reserver;
        this.set("reserverdirtyflag",true);
    }
    /**
     *  获取属性值[保留1]
     */
    public String getReserver(){
        return this.reserver;
    }
    /**
     *  重置属性值[保留1]
     */
    public void resetReserver(){
        this.set("reserverdirtyflag",false);
        this.reserver = null;
    }
    /**
     *  设置属性值[保留2]
     *  @param reserver2
     */
    public void setReserver2(String reserver2){
        if(StringUtils.isEmpty(reserver2))
            reserver2=null;
        this.reserver2 = reserver2;
        this.set("reserver2dirtyflag",true);
    }
    /**
     *  获取属性值[保留2]
     */
    public String getReserver2(){
        return this.reserver2;
    }
    /**
     *  重置属性值[保留2]
     */
    public void resetReserver2(){
        this.set("reserver2dirtyflag",false);
        this.reserver2 = null;
    }
    /**
     *  设置属性值[记录数量]
     *  @param rowamout
     */
    public void setRowamout(Integer rowamout){
        this.rowamout = rowamout;
        this.set("rowamoutdirtyflag",true);
    }
     /**
     *    rowamout :rowamount
     *   当属性名称与代码名称不一致时，
     *   多发一套get属性名称方法给gridvo用
     */
    public Integer getRowamount(){
        return  rowamout;
    }
     /**
     *    rowamout :rowamount
     *   关闭mp驼峰转换，当属性名称与代码名称不一致时，多发一套set用于值注入
     */
    public void setRowamount(Integer rowamount){
        this.rowamout=rowamount;
    }
    /**
     *  获取属性值[记录数量]
     */
    public Integer getRowamout(){
        return this.rowamout;
    }
    /**
     *  重置属性值[记录数量]
     */
    public void resetRowamout(){
        this.set("rowamoutdirtyflag",false);
        this.rowamout = null;
    }
    /**
     *  设置属性值[运行信息]
     *  @param rtinfo
     */
    public void setRtinfo(String rtinfo){
        if(StringUtils.isEmpty(rtinfo))
            rtinfo=null;
        this.rtinfo = rtinfo;
        this.set("rtinfodirtyflag",true);
    }
    /**
     *  获取属性值[运行信息]
     */
    public String getRtinfo(){
        return this.rtinfo;
    }
    /**
     *  重置属性值[运行信息]
     */
    public void resetRtinfo(){
        this.set("rtinfodirtyflag",false);
        this.rtinfo = null;
    }
    /**
     *  设置属性值[小图标]
     *  @param smallicon
     */
    public void setSmallicon(String smallicon){
        if(StringUtils.isEmpty(smallicon))
            smallicon=null;
        this.smallicon = smallicon;
        this.set("smallicondirtyflag",true);
    }
    /**
     *  获取属性值[小图标]
     */
    public String getSmallicon(){
        return this.smallicon;
    }
    /**
     *  重置属性值[小图标]
     */
    public void resetSmallicon(){
        this.set("smallicondirtyflag",false);
        this.smallicon = null;
    }
    /**
     *  设置属性值[实体存储类型]
     *  @param storagetype
     */
    public void setStoragetype(String storagetype){
        if(StringUtils.isEmpty(storagetype))
            storagetype=null;
        this.storagetype = storagetype;
        this.set("storagetypedirtyflag",true);
    }
    /**
     *  获取属性值[实体存储类型]
     */
    public String getStoragetype(){
        return this.storagetype;
    }
    /**
     *  重置属性值[实体存储类型]
     */
    public void resetStoragetype(){
        this.set("storagetypedirtyflag",false);
        this.storagetype = null;
    }
    /**
     *  设置属性值[表名称]
     *  @param tablename
     */
    public void setTablename(String tablename){
        if(StringUtils.isEmpty(tablename))
            tablename=null;
        this.tablename = tablename;
        this.set("tablenamedirtyflag",true);
    }
    /**
     *  获取属性值[表名称]
     */
    public String getTablename(){
        return this.tablename;
    }
    /**
     *  重置属性值[表名称]
     */
    public void resetTablename(){
        this.set("tablenamedirtyflag",false);
        this.tablename = null;
    }
    /**
     *  设置属性值[实体表空间]
     *  @param tablespace
     */
    public void setTablespace(String tablespace){
        if(StringUtils.isEmpty(tablespace))
            tablespace=null;
        this.tablespace = tablespace;
        this.set("tablespacedirtyflag",true);
    }
    /**
     *  获取属性值[实体表空间]
     */
    public String getTablespace(){
        return this.tablespace;
    }
    /**
     *  重置属性值[实体表空间]
     */
    public void resetTablespace(){
        this.set("tablespacedirtyflag",false);
        this.tablespace = null;
    }
    /**
     *  设置属性值[提示信息]
     *  @param tipsinfo
     */
    public void setTipsinfo(String tipsinfo){
        if(StringUtils.isEmpty(tipsinfo))
            tipsinfo=null;
        this.tipsinfo = tipsinfo;
        this.set("tipsinfodirtyflag",true);
    }
    /**
     *  获取属性值[提示信息]
     */
    public String getTipsinfo(){
        return this.tipsinfo;
    }
    /**
     *  重置属性值[提示信息]
     */
    public void resetTipsinfo(){
        this.set("tipsinfodirtyflag",false);
        this.tipsinfo = null;
    }
    /**
     *  设置属性值[提示处理对象]
     *  @param tipsobject
     */
    public void setTipsobject(String tipsobject){
        if(StringUtils.isEmpty(tipsobject))
            tipsobject=null;
        this.tipsobject = tipsobject;
        this.set("tipsobjectdirtyflag",true);
    }
    /**
     *  获取属性值[提示处理对象]
     */
    public String getTipsobject(){
        return this.tipsobject;
    }
    /**
     *  重置属性值[提示处理对象]
     */
    public void resetTipsobject(){
        this.set("tipsobjectdirtyflag",false);
        this.tipsobject = null;
    }
    /**
     *  设置属性值[更新时间]
     *  @param updatedate
     */
    public void setUpdatedate(Timestamp updatedate){
        this.updatedate = updatedate;
        this.set("updatedatedirtyflag",true);
    }
    /**
     *  获取属性值[更新时间]
     */
    public Timestamp getUpdatedate(){
        return this.updatedate;
    }
    /**
     *  重置属性值[更新时间]
     */
    public void resetUpdatedate(){
        this.set("updatedatedirtyflag",false);
        this.updatedate = null;
    }
    /**
     *  设置属性值[更新人]
     *  @param updateman
     */
    public void setUpdateman(String updateman){
        if(StringUtils.isEmpty(updateman))
            updateman=null;
        this.updateman = updateman;
        this.set("updatemandirtyflag",true);
    }
    /**
     *  获取属性值[更新人]
     */
    public String getUpdateman(){
        return this.updateman;
    }
    /**
     *  重置属性值[更新人]
     */
    public void resetUpdateman(){
        this.set("updatemandirtyflag",false);
        this.updateman = null;
    }
    /**
     *  设置属性值[用户数据行为]
     *  @param useraction
     */
    public void setUseraction(Integer useraction){
        this.useraction = useraction;
        this.set("useractiondirtyflag",true);
    }
    /**
     *  获取属性值[用户数据行为]
     */
    public Integer getUseraction(){
        return this.useraction;
    }
    /**
     *  重置属性值[用户数据行为]
     */
    public void resetUseraction(){
        this.set("useractiondirtyflag",false);
        this.useraction = null;
    }
    /**
     *  设置属性值[是否启用]
     *  @param validflag
     */
    public void setValidflag(Integer validflag){
        this.validflag = validflag;
        this.set("validflagdirtyflag",true);
    }
    /**
     *  获取属性值[是否启用]
     */
    public Integer getValidflag(){
        return this.validflag;
    }
    /**
     *  重置属性值[是否启用]
     */
    public void resetValidflag(){
        this.set("validflagdirtyflag",false);
        this.validflag = null;
    }
    /**
     *  设置属性值[启用数据版本控制]
     *  @param vcflag
     */
    public void setVcflag(Integer vcflag){
        this.vcflag = vcflag;
        this.set("vcflagdirtyflag",true);
    }
    /**
     *  获取属性值[启用数据版本控制]
     */
    public Integer getVcflag(){
        return this.vcflag;
    }
    /**
     *  重置属性值[启用数据版本控制]
     */
    public void resetVcflag(){
        this.set("vcflagdirtyflag",false);
        this.vcflag = null;
    }
    /**
     *  设置属性值[版本检查间隔]
     *  @param verchecktimer
     */
    public void setVerchecktimer(Integer verchecktimer){
        this.verchecktimer = verchecktimer;
        this.set("verchecktimerdirtyflag",true);
    }
    /**
     *  获取属性值[版本检查间隔]
     */
    public Integer getVerchecktimer(){
        return this.verchecktimer;
    }
    /**
     *  重置属性值[版本检查间隔]
     */
    public void resetVerchecktimer(){
        this.set("verchecktimerdirtyflag",false);
        this.verchecktimer = null;
    }
    /**
     *  设置属性值[版本属性]
     *  @param verfield
     */
    public void setVerfield(String verfield){
        if(StringUtils.isEmpty(verfield))
            verfield=null;
        this.verfield = verfield;
        this.set("verfielddirtyflag",true);
    }
    /**
     *  获取属性值[版本属性]
     */
    public String getVerfield(){
        return this.verfield;
    }
    /**
     *  重置属性值[版本属性]
     */
    public void resetVerfield(){
        this.set("verfielddirtyflag",false);
        this.verfield = null;
    }
    /**
     *  设置属性值[版本辅助对象]
     *  @param verhelper
     */
    public void setVerhelper(String verhelper){
        if(StringUtils.isEmpty(verhelper))
            verhelper=null;
        this.verhelper = verhelper;
        this.set("verhelperdirtyflag",true);
    }
    /**
     *  获取属性值[版本辅助对象]
     */
    public String getVerhelper(){
        return this.verhelper;
    }
    /**
     *  重置属性值[版本辅助对象]
     */
    public void resetVerhelper(){
        this.set("verhelperdirtyflag",false);
        this.verhelper = null;
    }
    /**
     *  设置属性值[版本检查]
     *  @param versioncheck
     */
    public void setVersioncheck(Integer versioncheck){
        this.versioncheck = versioncheck;
        this.set("versioncheckdirtyflag",true);
    }
    /**
     *  获取属性值[版本检查]
     */
    public Integer getVersioncheck(){
        return this.versioncheck;
    }
    /**
     *  重置属性值[版本检查]
     */
    public void resetVersioncheck(){
        this.set("versioncheckdirtyflag",false);
        this.versioncheck = null;
    }
    /**
     *  设置属性值[视图名称]
     *  @param viewname
     */
    public void setViewname(String viewname){
        if(StringUtils.isEmpty(viewname))
            viewname=null;
        this.viewname = viewname;
        this.set("viewnamedirtyflag",true);
    }
    /**
     *  获取属性值[视图名称]
     */
    public String getViewname(){
        return this.viewname;
    }
    /**
     *  重置属性值[视图名称]
     */
    public void resetViewname(){
        this.set("viewnamedirtyflag",false);
        this.viewname = null;
    }
     /**
     *  获取主实体关联数据[DataEntity]
     */
    public DataEntity getDer11de() {
        return der11de;
    }
    /**
     *  设置主实体关联数据[DataEntity]
     */
    public void setDer11de(DataEntity der11de) {
        this.der11de = der11de;
    }

     /**
     *  获取主实体关联数据[QueryModel]
     */
    public QueryModel getAcquerymodel() {
        return acquerymodel;
    }
    /**
     *  设置主实体关联数据[QueryModel]
     */
    public void setAcquerymodel(QueryModel acquerymodel) {
        this.acquerymodel = acquerymodel;
    }

    /**
     * 重置当前数据对象属性值
     */
    public  void reset(){
        resetAcenabledp();
        resetAcextinfo();
        resetAcinfoformat();
        resetAcinfoparam();
        resetAcmaxcnt();
        resetAcobject();
        resetAcquerymodelid();
        resetAcquerymodelname();
        resetAcsortdir();
        resetAcsortfield();
        resetBigicon();
        resetConfighelper();
        resetCreatedate();
        resetCreateman();
        resetDataaccobject();
        resetDatachglogmode();
        resetDatactrlint();
        resetDatactrlobject();
        resetDatanotifyhelper();
        resetDbstorage();
        resetDbversion();
        resetDegroup();
        resetDehelper();
        resetDeid();
        resetDelogicname();
        resetDename();
        resetDeobject();
        resetDeorder();
        resetDeparam();
        resetDer11deid();
        resetDer11dename();
        resetDetype();
        resetDeuserparam();
        resetDeversion();
        resetDgrowclasshelper();
        resetDgsummaryheight();
        resetDlkhelper();
        resetDynamicinterval();
        resetEnablecolpriv();
        resetEnableglobalmodel();
        resetExitingmodel();
        resetExportincempty();
        resetExtablename();
        resetGlobalmodelobj();
        resetIndexmode();
        resetInfofield();
        resetInfoformat();
        resetInheritmode();
        resetIsdgrowedit();
        resetIsenableaudit();
        resetIsenabledp();
        resetIsindexde();
        resetIslogicvalid();
        resetIsmultiprint();
        resetIssupportfa();
        resetIssystem();
        resetKeyparams();
        resetLicensecode();
        resetLogauditdetail();
        resetMemo();
        resetMinorfieldname();
        resetMinorfieldvalue();
        resetMinortablename();
        resetMutlimajor();
        resetNodatainfo();
        resetPrintfunc();
        resetReserver();
        resetReserver2();
        resetRowamout();
        resetRtinfo();
        resetSmallicon();
        resetStoragetype();
        resetTablename();
        resetTablespace();
        resetTipsinfo();
        resetTipsobject();
        resetUpdatedate();
        resetUpdateman();
        resetUseraction();
        resetValidflag();
        resetVcflag();
        resetVerchecktimer();
        resetVerfield();
        resetVerhelper();
        resetVersioncheck();
        resetViewname();
    }
     /**
     * 获取数据主键（普通主键与联合主键）
     * @return
     */
    @JsonIgnore
    public Serializable getDefaultPrimaryKey()
    {
	    //随机生成主键
         return  IdWorker.get32UUID();

    }
     /**
     * 复制当前对象数据到目标对象(粘贴重置)
     *
     * @throws Exception
     */
    public DataEntity copyTo(DataEntity targetEntity)
	{
		BeanCopier copier=BeanCopier.create(DataEntity.class, DataEntity.class, false);
		copier.copy(this, targetEntity, null);
        targetEntity.resetDeid();
		return targetEntity;
	}
}